MailDelivery.c

Go to the documentation of this file.

#include "derivative.h"
#include "Compile_Options.h"
#include "MailDelivery.h"
#include "eDMA.h"
#include "DSPI.h"
/*
 ******************************************************************************
 * Constants
 ******************************************************************************
 */

/*
 ******************************************************************************
 * Globals
 ******************************************************************************
 */
vuint32_t gau32DSPIOutbox[(OUTBOX_MAX_BUFFER_CNT + 1u) * 2u];
TCD_t    gatDSPIInbox[INBOX_MAX_BUFFER_CNT * 2u]; /* Today this is 4K */
vuint8_t gu8MailboxActiveOutboxOffset;
vint8_t gi8MailboxActiveInboxOffset;
vuint8_t gu8InboxDMA;
vuint8_t gu8InactiveInboxDMA;
vuint8_t gu8OutboxDMA;
vuint8_t gu8InactiveOutboxDMA;
/*
 ******************************************************************************
 * u8fnMailDeliveryOfOutboxInit
 ******************************************************************************
 */
uint8_t u8fnMailDeliveryOfOutboxInit(uint32_t* pu32Outbox,
                                     uint32_t* pu32Output, uint8_t u8DMAChannel)
{
  TCD_t tMyDefaultConfig;
    
  /* Outbox always has the size in its first address. Compensate for this */
  tMyDefaultConfig.P.SADDR = ((uint32_t)pu32Outbox + 4u);
  /* Destination address is our output vehicle (DSPI, for example) */
  tMyDefaultConfig.P.DADDR = (uint32_t)pu32Output;
  /* Modulus is 0 */
  tMyDefaultConfig.P.SMOD = CLEAR;
  tMyDefaultConfig.P.DMOD = CLEAR;
  /* We will transfer 32-bit words */
  tMyDefaultConfig.P.SSIZE = DMA_SIZE_32_BIT;
  tMyDefaultConfig.P.DSIZE = DMA_SIZE_32_BIT;
  tMyDefaultConfig.P.SOFF = 4u; /* Offset per minor loop (in bytes) */
  tMyDefaultConfig.P.DOFF = 0u; /* Destination offset per minor loop */
  tMyDefaultConfig.P.NBYTES = 4u; /* Inner loop transfer count (in bytes) */
  tMyDefaultConfig.P.SLAST = CLEAR;
  tMyDefaultConfig.P.CITERE_LINK = CLEAR;
  tMyDefaultConfig.P.BITERE_LINK = CLEAR;
  tMyDefaultConfig.P.CITER = 0u; /* Times we'll execute our minor loop */
  tMyDefaultConfig.P.BITER = 0u; /* Memory for the loop */
  tMyDefaultConfig.P.D_REQ = TRUE; /* Clear HW Start requests after major loop is done */
  
  tMyDefaultConfig.P.DLAST_SGA = CLEAR; /* Last destination offset */
  tMyDefaultConfig.P.MAJORLINKCH = CLEAR;
  tMyDefaultConfig.P.BWC = DMA_BWC_4_CYCLE_STALL;
  tMyDefaultConfig.P.MAJORE_LINK = CLEAR; /* Disable ch2ch linking */
  tMyDefaultConfig.P.E_SG = CLEAR;
  
  /* EDMA's DONE bit must be set to take the interrupt. This will be */
  /* updated as necessary, but for now, set it.                      */
  tMyDefaultConfig.P.DONE = TRUE;
  
  tMyDefaultConfig.P.INT_HALF = CLEAR;
  tMyDefaultConfig.P.INT_MAJ = CLEAR; /* No ISR for Outbox done */
  tMyDefaultConfig.P.START = CLEAR;
  
  vfnDMAConfig(&tMyDefaultConfig, u8DMAChannel);
  
  /* Config DMAMux to go along with it */
  vfnDMAMUXInit(u8DMAChannel, DMA_SOURCE_DSPI0_TX, CLEAR, TRUE);
  
  /* Remember which is the initial DMA we're using */
  gu8OutboxDMA = MAILDELIVERY_OUTBOX1_DMA_CH;
  gu8InactiveOutboxDMA = MAILDELIVERY_OUTBOX2_DMA_CH;
  
  return (CLEAR);
}
/*
 ******************************************************************************
 * u8fnMailDeliveryToInboxInit
 ******************************************************************************
 */
uint8_t u8fnMailDeliveryToInboxInit(uint16_t* pu16Input)
{
  uint8_t u8Counter;
  TCD_t tMyDefaultConfig;
  
  
  tMyDefaultConfig.P.SADDR = (uint32_t)pu16Input;
  tMyDefaultConfig.P.DADDR = (uint32_t)CLEAR;
  tMyDefaultConfig.P.SMOD = CLEAR;
  tMyDefaultConfig.P.DMOD = CLEAR;
  tMyDefaultConfig.P.SSIZE = DMA_SIZE_16_BIT;
  tMyDefaultConfig.P.DSIZE = DMA_SIZE_16_BIT;
  tMyDefaultConfig.P.SOFF = 0u; /* Offset per minor loop (in bytes) */
  tMyDefaultConfig.P.DOFF = 2u; /* Destination offset per minor loop */
  tMyDefaultConfig.P.NBYTES = 2u; /* Inner loop transfer count (in bytes) */
  tMyDefaultConfig.P.SLAST = CLEAR;
  tMyDefaultConfig.P.CITERE_LINK = CLEAR;
  tMyDefaultConfig.P.BITERE_LINK = CLEAR;
  tMyDefaultConfig.P.CITER = 0u; /* Times we'll execute our minor loop */
  tMyDefaultConfig.P.BITER = 0u; /* Memory for the loop */
  
  tMyDefaultConfig.P.DLAST_SGA = CLEAR; /* By default, zero. This will change with lnking */
  tMyDefaultConfig.P.MAJORLINKCH = MAILDELIVERY_INBOX1_DMA_CH;
  tMyDefaultConfig.P.BWC = DMA_BWC_4_CYCLE_STALL;
  tMyDefaultConfig.P.MAJORE_LINK = CLEAR; /* Disable ch2ch linking */
  tMyDefaultConfig.P.E_SG = CLEAR;
  tMyDefaultConfig.P.D_REQ = CLEAR; /* Will be modified as the stack grows */
  tMyDefaultConfig.P.INT_HALF = CLEAR;
  tMyDefaultConfig.P.INT_MAJ = CLEAR; /* Isr will be added as the stack grows */
  tMyDefaultConfig.P.DONE = CLEAR;
  tMyDefaultConfig.P.ACTIVE = CLEAR;
  tMyDefaultConfig.P.START = CLEAR;
  
  /* Copy values to predetermined INBOXes */
  vfnDMAConfig(&tMyDefaultConfig, MAILDELIVERY_INBOX1_DMA_CH);
  
  /* Configure all other inbox pointers associated to this one */
  for(u8Counter = MAILDELIVERY_INBOX1_DMA_INDEX_START; u8Counter
      <= MAILDELIVERY_INBOX1_DMA_INDEX_END; u8Counter++)
  {
    gatDSPIInbox[u8Counter] = tMyDefaultConfig;
  }

  /* Small mods for the second inbox family */
  tMyDefaultConfig.P.MAJORLINKCH = MAILDELIVERY_INBOX2_DMA_CH;
  
  /* Copy values to predetermined INBOXes */
  vfnDMAConfig(&tMyDefaultConfig, MAILDELIVERY_INBOX2_DMA_CH);
  for(u8Counter = MAILDELIVERY_INBOX2_DMA_INDEX_START; u8Counter
      <= MAILDELIVERY_INBOX2_DMA_INDEX_END; u8Counter++)
  {
    gatDSPIInbox[u8Counter] = tMyDefaultConfig;
  }

  /* Remember which DMA we're using */
  gu8InboxDMA = MAILDELIVERY_INBOX1_DMA_CH;
  gu8InactiveInboxDMA = MAILDELIVERY_INBOX2_DMA_CH;
  
  /* Config DMAMux to go along with it */
  vfnDMAMUXInit(gu8InboxDMA, DMA_SOURCE_DSPI0_RX, CLEAR, TRUE);
  
  return (CLEAR);
}
/*
 ******************************************************************************
 * vfnMailboxInit
 ******************************************************************************
 */
void vfnMailboxInit(void)
{
  /* Start by initializing outboxes */
  /* Erase count - contents is not relevant as it will be overwritten */
  gau32DSPIOutbox[OUTBOX_ACTIVE_OUTBOX_IS_1] = CLEAR;
  gau32DSPIOutbox[OUTBOX_ACTIVE_OUTBOX_IS_2] = CLEAR;
  
  /* First active Mailbox is the first half */
  gu8MailboxActiveOutboxOffset = OUTBOX_ACTIVE_OUTBOX_IS_1;
  gi8MailboxActiveInboxOffset  = MAILBOX_ACTIVE_INBOX_IS_1;
  
  return;
}

/*
 ******************************************************************************
 * u8fnMailboxAppendToInbox
 ******************************************************************************
 */
uint8_t u8fnMailboxAppendToInbox(const uint16_t* pu16MsgResponse,
                                 uint16_t u16Size)
{
  TCD_t*   ptCurrentTCD;
  TCD_t*   ptPreviousTCD;
  
  /* We need to find which registers we're modifying */
  if(MAILBOX_ACTIVE_INBOX_IS_1 == gi8MailboxActiveInboxOffset)
  {
    /* Modifying directly the DMA, no previous channel, start count for */
    /* gi8MailboxActiveInboxOffset.                                     */
    ptCurrentTCD = (TCD_t*)&(EDMA.TCD[MAILDELIVERY_INBOX1_DMA_CH]);
    ptPreviousTCD = (TCD_t*)MAILBOX_NO_PREVIOUS_INBOX;
    gi8MailboxActiveInboxOffset = MAILDELIVERY_INBOX1_DMA_INDEX_START;
  }
  else if(MAILBOX_ACTIVE_INBOX_IS_2 == gi8MailboxActiveInboxOffset)
  {
    /* Modifying directly the DMA, no previous channel, start count for */
    /* gi8MailboxActiveInboxOffset.                                     */
    ptCurrentTCD = (TCD_t*)&(EDMA.TCD[MAILDELIVERY_INBOX2_DMA_CH]);
    ptPreviousTCD = (TCD_t*)MAILBOX_NO_PREVIOUS_INBOX;
    gi8MailboxActiveInboxOffset = MAILDELIVERY_INBOX2_DMA_INDEX_START;
  }
  else
  {
    /* Modifying some location in RAM, and previous channel may come from */
    /* different sources.                                                 */
    ptCurrentTCD = &gatDSPIInbox[gi8MailboxActiveInboxOffset];
    if(MAILDELIVERY_INBOX1_DMA_INDEX_START == gi8MailboxActiveInboxOffset)
    {
      /* Previous value was in the DMA itself */
      ptPreviousTCD = (TCD_t*)&(EDMA.TCD[MAILDELIVERY_INBOX1_DMA_CH]);
    }
    else if(MAILDELIVERY_INBOX2_DMA_INDEX_START == gi8MailboxActiveInboxOffset)
    {
      /* Previous value was in the DMA itself */
      ptPreviousTCD = (TCD_t*)&(EDMA.TCD[MAILDELIVERY_INBOX2_DMA_CH]);
    }
    else
    {
      /* Previous channel was already in RAM */
      ptPreviousTCD = &gatDSPIInbox[gi8MailboxActiveInboxOffset - 1u];
    }
    /* Increment buffer count */
    gi8MailboxActiveInboxOffset++;
  }
  /* Start by modifying this TCD's number of Major cycles according to u16Size */
  ptCurrentTCD->P.CITER = u16Size;
  ptCurrentTCD->P.BITER = u16Size;
  
  /* Link to the pointer */
  ptCurrentTCD->P.DADDR = (uint32_t)pu16MsgResponse;
  
  /* Call the interrupt for when we're done */
  ptCurrentTCD->P.INT_MAJ = TRUE;
  
  /* Clear any existing "DONE" flags */
  ptCurrentTCD->P.DONE = CLEAR;
  
  /* Clear any existing links to load new config after transfer */
  ptCurrentTCD->P.DLAST_SGA = CLEAR;
  
  /* Disable loading any extra registers after this */
  ptCurrentTCD->P.E_SG = CLEAR;
  
  /* Continue only if we're not writing to the original inbox */
  if(MAILBOX_NO_PREVIOUS_INBOX != ptPreviousTCD)
  {
    /* Disable the Isr for the previous CH     */
    ptPreviousTCD->P.INT_MAJ = CLEAR;
      
    /* Enable loading of this info */
    ptPreviousTCD->P.E_SG = TRUE;
    
    /* Make sure that the next register is loaded */
    ptPreviousTCD->P.DLAST_SGA = (int32_t)(ptCurrentTCD);
  }
  else
  {
    /* Nothing I think... */
  }

  return (CLEAR);
}
/*
 ******************************************************************************
 * u8fnMailboxAppendToDSPIOutbox
 ******************************************************************************
 */
uint8_t u8fnMailboxAppendToDSPIOutbox(uint8_t u8DSPIInstance, uint8_t u8CS,
                                      uint8_t u8ContCS,
                                      uint8_t u8EndOfQueueFlag,
                                      uint16_t* pu16Msg, uint16_t u16Size)
{
  /* Locals */
  uint8_t u8Status;
  uint32_t u32Message;
  u8Status = CLEAR;

  /* Pre-calculate Message */
  /* Format as PUSHR for DSPI transfers */
  u32Message = FORMAT_PUSHR(u8DSPIInstance, 
                            u8CS, 
                            u8ContCS, 
                            u8EndOfQueueFlag, 
                            CLEAR);
  
  for(; CLEAR < u16Size; u16Size--)
  {
    /* Append to outbox */
    u8Status |= u8fnMailboxAppendToOutbox(
        (uint32_t*)(&gau32DSPIOutbox[gu8MailboxActiveOutboxOffset]),
        u32Message | *pu16Msg);
    /* Increment pointer to next value */
    pu16Msg++;
  }

  return (u8Status);
}
/*
 ******************************************************************************
 * u8fnMailboxAppendToDSPIOutbox
 ******************************************************************************
 */
uint8_t u8fnMailboxAppendToCompositeDSPIOutbox(uint8_t u8DSPIInstance1,
                                               uint8_t u8DSPIInstance2, 
                                               uint8_t u8CS,
                                               uint16_t* pu16Msg1, 
                                               uint16_t* pu16Msg2,
                                               uint16_t u16SizeAtOrigin)
{
  /* Locals */
  uint8_t u8Status;
  uint32_t u32Message1;
  uint32_t u32Message2;
  u8Status = CLEAR;
  
  /* Pre-calculate PUSHR */
  u32Message1 = FORMAT_PUSHR(u8DSPIInstance1, u8CS, TRUE, CLEAR, CLEAR);
  u32Message2 = FORMAT_PUSHR(u8DSPIInstance2, u8CS, CLEAR, CLEAR, CLEAR);
  
  for(; CLEAR < u16SizeAtOrigin; u16SizeAtOrigin--)
  {
    /* Append to outbox */
    u8Status |= u8fnMailboxAppendToOutbox(
        (uint32_t*)(&gau32DSPIOutbox[gu8MailboxActiveOutboxOffset]),
        u32Message1 | *pu16Msg1);
    /* Redo for Msg 2 */
    u8Status |= u8fnMailboxAppendToOutbox(
            (uint32_t*)(&gau32DSPIOutbox[gu8MailboxActiveOutboxOffset]),
            u32Message2 | *pu16Msg2);
    /* Increment pointer to next value */
    pu16Msg1++;
    pu16Msg2++;
  }

  return (u8Status);
}
/*
 ******************************************************************************
 * u8fnAppendToOutbox
 ******************************************************************************
 */
uint8_t u8fnMailboxAppendToOutbox(uint32_t* pu32Mailbox, uint32_t u32Message)
{
  /* Locals */
  uint8_t u8Status;
  
  /* Init locals */
  u8Status = CLEAR;
  
  if(OUTBOX_MAX_BUFFER_CNT > *pu32Mailbox)
  {
    (*pu32Mailbox)++;
    *(pu32Mailbox + *pu32Mailbox) = u32Message;
    
    /* increment pointers in outbox DMAs */
    /* Subtract equivalent values to when the major loop is done */
    /* CTAR will be copied to just before data is sent, and therefore is not */
    /* tinkered-with here. */
    EDMA.TCD[gu8OutboxDMA].BITER++;
    EDMA.TCD[gu8OutboxDMA].SLAST -= (4u);
  }
  else
  {
    u8Status = MAILBOX_CAPACITY_HAS_BEEN_REACHED;
  }
  return (u8Status);
}

/*
 ******************************************************************************
 * vfnMailDeliveryTriggerOutbox
 ******************************************************************************
 */
void vfnMailDeliveryTriggerOutbox(uint8_t u8DMAMuxChannel, uint8_t u8Enable)
{
  /* Copy BITER to CITER */
  EDMA.TCD[u8DMAMuxChannel].CITER = EDMA.TCD[u8DMAMuxChannel].BITER;
  
  /* Clear DONE flag */
  EDMA.TCD[u8DMAMuxChannel].DONE = CLEAR;
  
  /* Connect Proper EDMA HW Outbox triggers */
  EDMA.SERQR.R = u8DMAMuxChannel;
  
  vfnDMAMUXInit(u8DMAMuxChannel, DMA_SOURCE_DSPI0_TX, CLEAR, u8Enable);
  
  return;
}

/*
 ******************************************************************************
 * vfnMailboxSwitchActiveMailboxes
 ******************************************************************************
 */
void vfnMailboxSwitchActiveMailboxes(void)
{
  /* This routine shall be called when we want to switch the target outbox */
  /* to which code will be writing to. As such, it will also switch the    */
  /* active DMA channel associated with a given outbox.                    */

  if(MAILDELIVERY_OUTBOX1_DMA_CH == gu8OutboxDMA)
  {
    /* We're switchting to the second outbox. Clear its count. */
    gu8MailboxActiveOutboxOffset = OUTBOX_ACTIVE_OUTBOX_IS_2;
    gau32DSPIOutbox[OUTBOX_ACTIVE_OUTBOX_IS_2] = CLEAR;
    gi8MailboxActiveInboxOffset = MAILBOX_ACTIVE_INBOX_IS_2;
    
    gu8InactiveOutboxDMA = MAILDELIVERY_OUTBOX1_DMA_CH;
    gu8OutboxDMA = MAILDELIVERY_OUTBOX2_DMA_CH;
    gu8InactiveInboxDMA = MAILDELIVERY_INBOX1_DMA_CH;
    gu8InboxDMA = MAILDELIVERY_INBOX2_DMA_CH;
  }
  else
  {
    /* We're switching to the first outbox. Clear it's count */
    gu8MailboxActiveOutboxOffset = OUTBOX_ACTIVE_OUTBOX_IS_1;
    gau32DSPIOutbox[OUTBOX_ACTIVE_OUTBOX_IS_1] = CLEAR;
    gi8MailboxActiveInboxOffset = MAILBOX_ACTIVE_INBOX_IS_1;
    
    gu8InactiveOutboxDMA = MAILDELIVERY_OUTBOX2_DMA_CH;
    gu8OutboxDMA = MAILDELIVERY_OUTBOX1_DMA_CH;
    gu8InactiveInboxDMA = MAILDELIVERY_INBOX2_DMA_CH;
    gu8InboxDMA = MAILDELIVERY_INBOX1_DMA_CH;
  }
  
  /* Reset count before writing anything for output */
  EDMA.TCD[gu8OutboxDMA].SLAST = CLEAR;
  
  return;
}
/*
 ******************************************************************************
 *
 *  End of file.
 *
 ******************************************************************************
 */